home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2007 September / PCWSEP07.iso / Software / Linux / Linux Mint 3.0 Light / LinuxMint-3.0-Light.iso / casper / filesystem.squashfs / usr / lib / python2.5 / socket.py < prev    next >
Encoding:
Python Source  |  2007-05-02  |  12.9 KB  |  415 lines
  1. # Wrapper module for _socket, providing some additional facilities
  2. # implemented in Python.
  3.  
  4. """\
  5. This module provides socket operations and some related functions.
  6. On Unix, it supports IP (Internet Protocol) and Unix domain sockets.
  7. On other systems, it only supports IP. Functions specific for a
  8. socket are available as methods of the socket object.
  9.  
  10. Functions:
  11.  
  12. socket() -- create a new socket object
  13. socketpair() -- create a pair of new socket objects [*]
  14. fromfd() -- create a socket object from an open file descriptor [*]
  15. gethostname() -- return the current hostname
  16. gethostbyname() -- map a hostname to its IP number
  17. gethostbyaddr() -- map an IP number or hostname to DNS info
  18. getservbyname() -- map a service name and a protocol name to a port number
  19. getprotobyname() -- mape a protocol name (e.g. 'tcp') to a number
  20. ntohs(), ntohl() -- convert 16, 32 bit int from network to host byte order
  21. htons(), htonl() -- convert 16, 32 bit int from host to network byte order
  22. inet_aton() -- convert IP addr string (123.45.67.89) to 32-bit packed format
  23. inet_ntoa() -- convert 32-bit packed format IP to string (123.45.67.89)
  24. ssl() -- secure socket layer support (only available if configured)
  25. socket.getdefaulttimeout() -- get the default timeout value
  26. socket.setdefaulttimeout() -- set the default timeout value
  27.  
  28.  [*] not available on all platforms!
  29.  
  30. Special objects:
  31.  
  32. SocketType -- type object for socket objects
  33. error -- exception raised for I/O errors
  34. has_ipv6 -- boolean value indicating if IPv6 is supported
  35.  
  36. Integer constants:
  37.  
  38. AF_INET, AF_UNIX -- socket domains (first argument to socket() call)
  39. SOCK_STREAM, SOCK_DGRAM, SOCK_RAW -- socket types (second argument)
  40.  
  41. Many other constants may be defined; these may be used in calls to
  42. the setsockopt() and getsockopt() methods.
  43. """
  44.  
  45. import _socket
  46. from _socket import *
  47.  
  48. _have_ssl = False
  49. try:
  50.     import _ssl
  51.     from _ssl import *
  52.     _have_ssl = True
  53. except ImportError:
  54.     pass
  55.  
  56. import os, sys
  57.  
  58. try:
  59.     from errno import EBADF
  60. except ImportError:
  61.     EBADF = 9
  62.  
  63. __all__ = ["getfqdn"]
  64. __all__.extend(os._get_exports_list(_socket))
  65. if _have_ssl:
  66.     __all__.extend(os._get_exports_list(_ssl))
  67.  
  68. _realsocket = socket
  69. if _have_ssl:
  70.     _realssl = ssl
  71.     def ssl(sock, keyfile=None, certfile=None):
  72.         if hasattr(sock, "_sock"):
  73.             sock = sock._sock
  74.         return _realssl(sock, keyfile, certfile)
  75.  
  76. # WSA error codes
  77. if sys.platform.lower().startswith("win"):
  78.     errorTab = {}
  79.     errorTab[10004] = "The operation was interrupted."
  80.     errorTab[10009] = "A bad file handle was passed."
  81.     errorTab[10013] = "Permission denied."
  82.     errorTab[10014] = "A fault occurred on the network??" # WSAEFAULT
  83.     errorTab[10022] = "An invalid operation was attempted."
  84.     errorTab[10035] = "The socket operation would block"
  85.     errorTab[10036] = "A blocking operation is already in progress."
  86.     errorTab[10048] = "The network address is in use."
  87.     errorTab[10054] = "The connection has been reset."
  88.     errorTab[10058] = "The network has been shut down."
  89.     errorTab[10060] = "The operation timed out."
  90.     errorTab[10061] = "Connection refused."
  91.     errorTab[10063] = "The name is too long."
  92.     errorTab[10064] = "The host is down."
  93.     errorTab[10065] = "The host is unreachable."
  94.     __all__.append("errorTab")
  95.  
  96.  
  97.  
  98. def getfqdn(name=''):
  99.     """Get fully qualified domain name from name.
  100.  
  101.     An empty argument is interpreted as meaning the local host.
  102.  
  103.     First the hostname returned by gethostbyaddr() is checked, then
  104.     possibly existing aliases. In case no FQDN is available, hostname
  105.     from gethostname() is returned.
  106.     """
  107.     name = name.strip()
  108.     if not name or name == '0.0.0.0':
  109.         name = gethostname()
  110.     try:
  111.         hostname, aliases, ipaddrs = gethostbyaddr(name)
  112.     except error:
  113.         pass
  114.     else:
  115.         aliases.insert(0, hostname)
  116.         for name in aliases:
  117.             if '.' in name:
  118.                 break
  119.         else:
  120.             name = hostname
  121.     return name
  122.  
  123.  
  124. _socketmethods = (
  125.     'bind', 'connect', 'connect_ex', 'fileno', 'listen',
  126.     'getpeername', 'getsockname', 'getsockopt', 'setsockopt',
  127.     'sendall', 'setblocking',
  128.     'settimeout', 'gettimeout', 'shutdown')
  129.  
  130. if sys.platform == "riscos":
  131.     _socketmethods = _socketmethods + ('sleeptaskw',)
  132.  
  133. # All the method names that must be delegated to either the real socket
  134. # object or the _closedsocket object.
  135. _delegate_methods = ("recv", "recvfrom", "recv_into", "recvfrom_into",
  136.                      "send", "sendto")
  137.  
  138. class _closedsocket(object):
  139.     __slots__ = []
  140.     def _dummy(*args):
  141.         raise error(EBADF, 'Bad file descriptor')
  142.     # All _delegate_methods must also be initialized here.
  143.     send = recv = recv_into = sendto = recvfrom = recvfrom_into = _dummy
  144.     __getattr__ = _dummy
  145.  
  146. class _socketobject(object):
  147.  
  148.     __doc__ = _realsocket.__doc__
  149.  
  150.     __slots__ = ["_sock", "__weakref__"] + list(_delegate_methods)
  151.  
  152.     def __init__(self, family=AF_INET, type=SOCK_STREAM, proto=0, _sock=None):
  153.         if _sock is None:
  154.             _sock = _realsocket(family, type, proto)
  155.         self._sock = _sock
  156.         for method in _delegate_methods:
  157.             setattr(self, method, getattr(_sock, method))
  158.  
  159.     def close(self):
  160.         self._sock = _closedsocket()
  161.         dummy = self._sock._dummy
  162.         for method in _delegate_methods:
  163.             setattr(self, method, dummy)
  164.     close.__doc__ = _realsocket.close.__doc__
  165.  
  166.     def accept(self):
  167.         sock, addr = self._sock.accept()
  168.         return _socketobject(_sock=sock), addr
  169.     accept.__doc__ = _realsocket.accept.__doc__
  170.  
  171.     def dup(self):
  172.         """dup() -> socket object
  173.  
  174.         Return a new socket object connected to the same system resource."""
  175.         return _socketobject(_sock=self._sock)
  176.  
  177.     def makefile(self, mode='r', bufsize=-1):
  178.         """makefile([mode[, bufsize]]) -> file object
  179.  
  180.         Return a regular file object corresponding to the socket.  The mode
  181.         and bufsize arguments are as for the built-in open() function."""
  182.         return _fileobject(self._sock, mode, bufsize)
  183.  
  184.     family = property(lambda self: self._sock.family, doc="the socket family")
  185.     type = property(lambda self: self._sock.type, doc="the socket type")
  186.     proto = property(lambda self: self._sock.proto, doc="the socket protocol")
  187.  
  188.     _s = ("def %s(self, *args): return self._sock.%s(*args)\n\n"
  189.           "%s.__doc__ = _realsocket.%s.__doc__\n")
  190.     for _m in _socketmethods:
  191.         exec _s % (_m, _m, _m, _m)
  192.     del _m, _s
  193.  
  194. socket = SocketType = _socketobject
  195.  
  196. class _fileobject(object):
  197.     """Faux file object attached to a socket object."""
  198.  
  199.     default_bufsize = 8192
  200.     name = "<socket>"
  201.  
  202.     __slots__ = ["mode", "bufsize", "softspace",
  203.                  # "closed" is a property, see below
  204.                  "_sock", "_rbufsize", "_wbufsize", "_rbuf", "_wbuf",
  205.                  "_close"]
  206.  
  207.     def __init__(self, sock, mode='rb', bufsize=-1, close=False):
  208.         self._sock = sock
  209.         self.mode = mode # Not actually used in this version
  210.         if bufsize < 0:
  211.             bufsize = self.default_bufsize
  212.         self.bufsize = bufsize
  213.         self.softspace = False
  214.         if bufsize == 0:
  215.             self._rbufsize = 1
  216.         elif bufsize == 1:
  217.             self._rbufsize = self.default_bufsize
  218.         else:
  219.             self._rbufsize = bufsize
  220.         self._wbufsize = bufsize
  221.         self._rbuf = "" # A string
  222.         self._wbuf = [] # A list of strings
  223.         self._close = close
  224.  
  225.     def _getclosed(self):
  226.         return self._sock is None
  227.     closed = property(_getclosed, doc="True if the file is closed")
  228.  
  229.     def close(self):
  230.         try:
  231.             if self._sock:
  232.                 self.flush()
  233.         finally:
  234.             if self._close:
  235.                 self._sock.close()
  236.             self._sock = None
  237.  
  238.     def __del__(self):
  239.         try:
  240.             self.close()
  241.         except:
  242.             # close() may fail if __init__ didn't complete
  243.             pass
  244.  
  245.     def flush(self):
  246.         if self._wbuf:
  247.             buffer = "".join(self._wbuf)
  248.             self._wbuf = []
  249.             self._sock.sendall(buffer)
  250.  
  251.     def fileno(self):
  252.         return self._sock.fileno()
  253.  
  254.     def write(self, data):
  255.         data = str(data) # XXX Should really reject non-string non-buffers
  256.         if not data:
  257.             return
  258.         self._wbuf.append(data)
  259.         if (self._wbufsize == 0 or
  260.             self._wbufsize == 1 and '\n' in data or
  261.             self._get_wbuf_len() >= self._wbufsize):
  262.             self.flush()
  263.  
  264.     def writelines(self, list):
  265.         # XXX We could do better here for very long lists
  266.         # XXX Should really reject non-string non-buffers
  267.         self._wbuf.extend(filter(None, map(str, list)))
  268.         if (self._wbufsize <= 1 or
  269.             self._get_wbuf_len() >= self._wbufsize):
  270.             self.flush()
  271.  
  272.     def _get_wbuf_len(self):
  273.         buf_len = 0
  274.         for x in self._wbuf:
  275.             buf_len += len(x)
  276.         return buf_len
  277.  
  278.     def read(self, size=-1):
  279.         data = self._rbuf
  280.         if size < 0:
  281.             # Read until EOF
  282.             buffers = []
  283.             if data:
  284.                 buffers.append(data)
  285.             self._rbuf = ""
  286.             if self._rbufsize <= 1:
  287.                 recv_size = self.default_bufsize
  288.             else:
  289.                 recv_size = self._rbufsize
  290.             while True:
  291.                 data = self._sock.recv(recv_size)
  292.                 if not data:
  293.                     break
  294.                 buffers.append(data)
  295.             return "".join(buffers)
  296.         else:
  297.             # Read until size bytes or EOF seen, whichever comes first
  298.             buf_len = len(data)
  299.             if buf_len >= size:
  300.                 self._rbuf = data[size:]
  301.                 return data[:size]
  302.             buffers = []
  303.             if data:
  304.                 buffers.append(data)
  305.             self._rbuf = ""
  306.             while True:
  307.                 left = size - buf_len
  308.                 recv_size = max(self._rbufsize, left)
  309.                 data = self._sock.recv(recv_size)
  310.                 if not data:
  311.                     break
  312.                 buffers.append(data)
  313.                 n = len(data)
  314.                 if n >= left:
  315.                     self._rbuf = data[left:]
  316.                     buffers[-1] = data[:left]
  317.                     break
  318.                 buf_len += n
  319.             return "".join(buffers)
  320.  
  321.     def readline(self, size=-1):
  322.         data = self._rbuf
  323.         if size < 0:
  324.             # Read until \n or EOF, whichever comes first
  325.             if self._rbufsize <= 1:
  326.                 # Speed up unbuffered case
  327.                 assert data == ""
  328.                 buffers = []
  329.                 recv = self._sock.recv
  330.                 while data != "\n":
  331.                     data = recv(1)
  332.                     if not data:
  333.                         break
  334.                     buffers.append(data)
  335.                 return "".join(buffers)
  336.             nl = data.find('\n')
  337.             if nl >= 0:
  338.                 nl += 1
  339.                 self._rbuf = data[nl:]
  340.                 return data[:nl]
  341.             buffers = []
  342.             if data:
  343.                 buffers.append(data)
  344.             self._rbuf = ""
  345.             while True:
  346.                 data = self._sock.recv(self._rbufsize)
  347.                 if not data:
  348.                     break
  349.                 buffers.append(data)
  350.                 nl = data.find('\n')
  351.                 if nl >= 0:
  352.                     nl += 1
  353.                     self._rbuf = data[nl:]
  354.                     buffers[-1] = data[:nl]
  355.                     break
  356.             return "".join(buffers)
  357.         else:
  358.             # Read until size bytes or \n or EOF seen, whichever comes first
  359.             nl = data.find('\n', 0, size)
  360.             if nl >= 0:
  361.                 nl += 1
  362.                 self._rbuf = data[nl:]
  363.                 return data[:nl]
  364.             buf_len = len(data)
  365.             if buf_len >= size:
  366.                 self._rbuf = data[size:]
  367.                 return data[:size]
  368.             buffers = []
  369.             if data:
  370.                 buffers.append(data)
  371.             self._rbuf = ""
  372.             while True:
  373.                 data = self._sock.recv(self._rbufsize)
  374.                 if not data:
  375.                     break
  376.                 buffers.append(data)
  377.                 left = size - buf_len
  378.                 nl = data.find('\n', 0, left)
  379.                 if nl >= 0:
  380.                     nl += 1
  381.                     self._rbuf = data[nl:]
  382.                     buffers[-1] = data[:nl]
  383.                     break
  384.                 n = len(data)
  385.                 if n >= left:
  386.                     self._rbuf = data[left:]
  387.                     buffers[-1] = data[:left]
  388.                     break
  389.                 buf_len += n
  390.             return "".join(buffers)
  391.  
  392.     def readlines(self, sizehint=0):
  393.         total = 0
  394.         list = []
  395.         while True:
  396.             line = self.readline()
  397.             if not line:
  398.                 break
  399.             list.append(line)
  400.             total += len(line)
  401.             if sizehint and total >= sizehint:
  402.                 break
  403.         return list
  404.  
  405.     # Iterator protocols
  406.  
  407.     def __iter__(self):
  408.         return self
  409.  
  410.     def next(self):
  411.         line = self.readline()
  412.         if not line:
  413.             raise StopIteration
  414.         return line
  415.